టైప్‌స్క్రిప్ట్ జెనరిక్స్: అధునాతన వినియోగ నమూనాలు

టైప్‌స్క్రిప్ట్ జెనరిక్స్ ఒక శక్తివంతమైన ఫీచర్, ఇది మరింత ఫ్లెక్సిబుల్, పునర్వినియోగ, మరియు టైప్-సేఫ్ కోడ్ రాయడానికి మిమ్మల్ని అనుమతిస్తుంది. కంపైల్ సమయంలో టైప్ చెకింగ్‌ను కొనసాగిస్తూనే, వివిధ రకాల ఇతర రకాలతో పనిచేయగల రకాలను నిర్వచించడానికి అవి మిమ్మల్ని అనుమతిస్తాయి. ఈ బ్లాగ్ పోస్ట్ అధునాతన వినియోగ నమూనాలలోకి లోతుగా వెళుతుంది, వారి భౌగోళిక స్థానం లేదా నేపథ్యంతో సంబంధం లేకుండా, అన్ని స్థాయిల డెవలపర్‌లకు ఆచరణాత్మక ఉదాహరణలు మరియు అంతర్దృష్టులను అందిస్తుంది.

ప్రాథమిక అంశాలను అర్థం చేసుకోవడం: ఒక పునశ్చరణ

అధునాతన విషయాలలోకి వెళ్లే ముందు, ప్రాథమికాలను త్వరగా పునశ్చరణ చేద్దాం. జెనరిక్స్ ఒకే రకానికి బదులుగా వివిధ రకాలతో పనిచేయగల కాంపోనెంట్లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తాయి. మీరు ఫంక్షన్ లేదా క్లాస్ పేరు తర్వాత యాంగిల్ బ్రాకెట్లలో (`<>`) ఒక జెనరిక్ టైప్ పరామితిని ప్రకటిస్తారు. ఈ పరామితి ఫంక్షన్ లేదా క్లాస్ ఉపయోగించినప్పుడు తర్వాత పేర్కొనబడే వాస్తవ రకానికి ప్లేస్‌హోల్డర్‌గా పనిచేస్తుంది.

ఉదాహరణకు, ఒక సాధారణ జెనరిక్ ఫంక్షన్ ఇలా ఉండవచ్చు:

            function identity(arg: T): T {
  return arg;
}

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, T అనేది జెనరిక్ టైప్ పరామితి. identity ఫంక్షన్ T రకం యొక్క ఆర్గ్యుమెంట్‌ను తీసుకుని T రకం యొక్క విలువను తిరిగి ఇస్తుంది. మీరు ఈ ఫంక్షన్‌ను వివిధ రకాలతో పిలవవచ్చు:

            
let stringResult: string = identity("hello");
let numberResult: number = identity(42);

            

              
                Copy
              
            
          

అధునాతన జెనరిక్స్: ప్రాథమికాలకు మించి

ఇప్పుడు, జెనరిక్స్‌ను ఉపయోగించుకోవడానికి మరింత అధునాతన మార్గాలను అన్వేషిద్దాం.

1. జెనరిక్ టైప్ కన్స్ట్రెయింట్స్

టైప్ కన్స్ట్రెయింట్స్ ఒక జెనరిక్ టైప్ పరామితితో ఉపయోగించగల రకాలను పరిమితం చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. ఒక జెనరిక్ రకానికి నిర్దిష్ట ప్రాపర్టీలు లేదా మెథడ్స్ ఉన్నాయని నిర్ధారించుకోవలసినప్పుడు ఇది చాలా ముఖ్యం. మీరు ఒక కన్స్ట్రెయింట్‌ను పేర్కొనడానికి extends కీవర్డ్‌ను ఉపయోగించవచ్చు.

ఒక ఫంక్షన్ length ప్రాపర్టీని యాక్సెస్ చేయాలనుకునే ఉదాహరణను పరిగణించండి:

            function loggingIdentity(arg: T): T {
  console.log(arg.length);
  return arg;
}

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, T అనేది number రకం యొక్క length ప్రాపర్టీని కలిగి ఉన్న రకాలకు పరిమితం చేయబడింది. ఇది మనకు సురక్షితంగా arg.length ను యాక్సెస్ చేయడానికి అనుమతిస్తుంది. ఈ కన్స్ట్రెయింట్‌ను సంతృప్తిపరచని రకాన్ని పాస్ చేయడానికి ప్రయత్నిస్తే కంపైల్-టైమ్ లోపం వస్తుంది.

ప్రపంచవ్యాప్త అనువర్తనం: ఇది డేటా ప్రాసెసింగ్, ఉదాహరణకు అర్రేలు లేదా స్ట్రింగ్స్‌తో పనిచేసేటప్పుడు, పొడవు తెలుసుకోవలసిన సందర్భాలలో ప్రత్యేకంగా ఉపయోగపడుతుంది. మీరు టోక్యో, లండన్, లేదా రియో డి జనీరోలో ఉన్నా ఈ నమూనా ఒకే విధంగా పనిచేస్తుంది.

2. ఇంటర్‌ఫేస్‌లతో జెనరిక్‌ను ఉపయోగించడం

జెనరిక్స్ ఇంటర్‌ఫేస్‌లతో సజావుగా పనిచేస్తాయి, ఫ్లెక్సిబుల్ మరియు పునర్వినియోగ ఇంటర్‌ఫేస్ నిర్వచనాలను నిర్వచించడానికి మిమ్మల్ని అనుమతిస్తాయి.

            interface GenericIdentityFn {
  (arg: T): T;
}

function identity(arg: T): T {
  return arg;
}

let myIdentity: GenericIdentityFn = identity;

            

              
                Copy
              
            
          

ఇక్కడ, GenericIdentityFn అనేది ఒక జెనరిక్ రకం T ను తీసుకుని అదే రకం T ను తిరిగి ఇచ్చే ఫంక్షన్‌ను వివరించే ఒక ఇంటర్‌ఫేస్. ఇది టైప్ సేఫ్టీని కొనసాగిస్తూనే వివిధ టైప్ సిగ్నేచర్‌లతో ఫంక్షన్లను నిర్వచించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ప్రపంచవ్యాప్త దృక్పథం: ఈ నమూనా వివిధ రకాల ఆబ్జెక్ట్‌ల కోసం పునర్వినియోగ ఇంటర్‌ఫేస్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఉదాహరణకు, మీరు వివిధ APIలలో ఉపయోగించే డేటా ట్రాన్స్‌ఫర్ ఆబ్జెక్ట్‌ల (DTOs) కోసం ఒక జెనరిక్ ఇంటర్‌ఫేస్‌ను సృష్టించవచ్చు, ఇది మీ అప్లికేషన్‌లో అది అమలు చేయబడిన ప్రాంతంతో సంబంధం లేకుండా స్థిరమైన డేటా నిర్మాణాలను నిర్ధారిస్తుంది.

3. జెనరిక్ క్లాసులు

క్లాసులు కూడా జెనరిక్‌గా ఉండవచ్చు:

            
class GenericNumber {
  zeroValue: T;
  add: (x: T, y: T) => T;
}

let myGenericNumber = new GenericNumber();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };

            

              
                Copy
              
            
          

ఈ క్లాస్ GenericNumber T రకం యొక్క విలువను కలిగి ఉంటుంది మరియు T రకం మీద పనిచేసే ఒక add మెథడ్‌ను నిర్వచిస్తుంది. మీరు కావలసిన రకంతో క్లాస్‌ను ఇన్‌స్టాన్షియేట్ చేస్తారు. స్టాక్స్ లేదా క్యూస్ వంటి డేటా నిర్మాణాలను సృష్టించడానికి ఇది చాలా సహాయకరంగా ఉంటుంది.

ప్రపంచవ్యాప్త అనువర్తనం: వివిధ కరెన్సీలను (ఉదా., USD, EUR, JPY) నిల్వ చేసి, ప్రాసెస్ చేయాల్సిన ఆర్థిక అప్లికేషన్‌ను ఊహించుకోండి. మీరు ఒక జెనరిక్ క్లాస్‌ను ఉపయోగించి CurrencyAmount క్లాస్‌ను సృష్టించవచ్చు, ఇక్కడ T కరెన్సీ రకాన్ని సూచిస్తుంది, ఇది వివిధ కరెన్సీ మొత్తాల టైప్-సేఫ్ గణనలు మరియు నిల్వను అనుమతిస్తుంది.

4. బహుళ టైప్ పరామితులు

జెనరిక్స్ బహుళ టైప్ పరామితులను ఉపయోగించవచ్చు:

            
function swap(a: T, b: U): [U, T] {
  return [b, a];
}

let result = swap("hello", 42);
// result[0] is number, result[1] is string

            

              
                Copy
              
            
          

swap ఫంక్షన్ వివిధ రకాల రెండు ఆర్గ్యుమెంట్‌లను తీసుకుని రకాలు మార్చబడిన ఒక టపుల్‌ను తిరిగి ఇస్తుంది.

ప్రపంచవ్యాప్త ప్రాముఖ్యత: అంతర్జాతీయ వ్యాపార అప్లికేషన్లలో, మీరు వివిధ రకాల రెండు సంబంధిత డేటా ముక్కలను తీసుకుని వాటి టపుల్‌ను తిరిగి ఇచ్చే ఒక ఫంక్షన్‌ను కలిగి ఉండవచ్చు, ఉదాహరణకు కస్టమర్ ID (స్ట్రింగ్) మరియు ఆర్డర్ విలువ (సంఖ్య). ఈ నమూనా ఏ నిర్దిష్ట దేశానికి అనుకూలంగా ఉండదు మరియు ప్రపంచ అవసరాలకు సంపూర్ణంగా అనుగుణంగా ఉంటుంది.

5. జెనరిక్ కన్స్ట్రెయింట్స్‌లో టైప్ పరామితులను ఉపయోగించడం

మీరు ఒక కన్స్ట్రెయింట్‌లో ఒక టైప్ పరామితిని ఉపయోగించవచ్చు.

            
function getProperty(obj: T, key: K) {
  return obj[key];
}

let obj = { a: 1, b: 2, c: 3 };

let value = getProperty(obj, "a"); // value is number

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, K extends keyof T అంటే K కేవలం T రకం యొక్క కీ మాత్రమే కాగలదు. ఇది ఆబ్జెక్ట్ ప్రాపర్టీలను డైనమిక్‌గా యాక్సెస్ చేసేటప్పుడు బలమైన టైప్ సేఫ్టీని అందిస్తుంది.

ప్రపంచవ్యాప్త వర్తనీయత: కాన్ఫిగరేషన్ ఆబ్జెక్ట్‌లు లేదా డేటా నిర్మాణాలతో పనిచేసేటప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది, ఇక్కడ ప్రాపర్టీ యాక్సెస్ డెవలప్‌మెంట్ సమయంలో ధృవీకరించబడాలి. ఈ టెక్నిక్‌ను ఏ దేశంలోని అప్లికేషన్లలోనైనా వర్తింపజేయవచ్చు.

6. జెనరిక్ యుటిలిటీ రకాలు

టైప్‌స్క్రిప్ట్ అనేక అంతర్నిర్మిత యుటిలిటీ రకాలను అందిస్తుంది, ఇవి సాధారణ టైప్ ట్రాన్స్‌ఫర్మేషన్లను నిర్వహించడానికి జెనరిక్స్‌ను ఉపయోగిస్తాయి. వీటిలో ఇవి ఉన్నాయి:

• Partial: T యొక్క అన్ని ప్రాపర్టీలను ఐచ్ఛికం చేస్తుంది.
• Required: T యొక్క అన్ని ప్రాపర్టీలను తప్పనిసరి చేస్తుంది.
• Readonly: T యొక్క అన్ని ప్రాపర్టీలను రీడ్-ఓన్లీ చేస్తుంది.
• Pick: T నుండి ప్రాపర్టీల సమితిని ఎంచుకుంటుంది.
• Omit: T నుండి ప్రాపర్టీల సమితిని తొలగిస్తుంది.

ఉదాహరణకు:

            
interface User {
  id: number;
  name: string;
  email: string;
}

// Partial - all properties optional
let optionalUser: Partial = {};

// Pick - only id and name properties
let userSummary: Pick = { id: 1, name: 'John' };

            

              
                Copy
              
            
          

ప్రపంచవ్యాప్త వినియోగ సందర్భం: API అభ్యర్థన మరియు ప్రతిస్పందన మోడల్‌లను సృష్టించేటప్పుడు ఈ యుటిలిటీలు అమూల్యమైనవి. ఉదాహరణకు, ఒక గ్లోబల్ ఇ-కామర్స్ అప్లికేషన్‌లో, Partial ఒక అప్‌డేట్ అభ్యర్థనను సూచించడానికి ఉపయోగించవచ్చు (ఇక్కడ కొన్ని ఉత్పత్తి వివరాలు మాత్రమే పంపబడతాయి), అయితే Readonly ఫ్రంటెండ్‌లో ప్రదర్శించబడే ఒక ఉత్పత్తిని సూచించవచ్చు.

7. జెనరిక్స్‌తో టైప్ ఇన్ఫరెన్స్

టైప్‌స్క్రిప్ట్ తరచుగా మీరు ఒక జెనరిక్ ఫంక్షన్ లేదా క్లాస్‌కు పాస్ చేసే ఆర్గ్యుమెంట్ల ఆధారంగా టైప్ పరామితులను ఊహించగలదు. ఇది మీ కోడ్‌ను శుభ్రంగా మరియు చదవడానికి సులభంగా చేయగలదు.

            
function createPair(a: T, b: T): [T, T] {
  return [a, b];
}

let pair = createPair("hello", "world"); // TypeScript infers T as string

            

              
                Copy
              
            
          

ఈ సందర్భంలో, టైప్‌స్క్రిప్ట్ స్వయంచాలకంగా T అనేది string అని ఊహిస్తుంది ఎందుకంటే రెండు ఆర్గ్యుమెంట్లు స్ట్రింగ్స్.

ప్రపంచవ్యాప్త ప్రభావం: టైప్ ఇన్ఫరెన్స్ స్పష్టమైన టైప్ అనోటేషన్ల అవసరాన్ని తగ్గిస్తుంది, ఇది మీ కోడ్‌ను మరింత సంక్షిప్తంగా మరియు చదవడానికి వీలుగా చేస్తుంది. ఇది విభిన్న అభివృద్ధి బృందాలలో సహకారాన్ని మెరుగుపరుస్తుంది, ఇక్కడ వివిధ స్థాయిల అనుభవం ఉండవచ్చు.

8. జెనరిక్స్‌తో కండిషనల్ రకాలు

కండిషనల్ రకాలు, జెనరిక్స్‌తో కలిసి, ఇతర రకాల విలువలపై ఆధారపడే రకాలను సృష్టించడానికి ఒక శక్తివంతమైన మార్గాన్ని అందిస్తాయి.

            
type Check = T extends string ? string : number;

let result1: Check = "hello"; // string
let result2: Check = 42; // number

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, Check అనేది T string ను విస్తరిస్తే string గా మూల్యాంకనం చేయబడుతుంది, లేకపోతే అది number గా మూల్యాంకనం చేయబడుతుంది.

ప్రపంచవ్యాప్త సందర్భం: కొన్ని షరతుల ఆధారంగా రకాలను డైనమిక్‌గా ఆకృతి చేయడానికి కండిషనల్ రకాలు అత్యంత ఉపయోగకరంగా ఉంటాయి. ప్రాంతం ఆధారంగా డేటాను ప్రాసెస్ చేసే ఒక వ్యవస్థను ఊహించుకోండి. కండిషనల్ రకాలను ఉపయోగించి ప్రాంత-నిర్దిష్ట డేటా ఫార్మాట్లు లేదా డేటా రకాల ఆధారంగా డేటాను మార్చవచ్చు. ప్రపంచ డేటా పరిపాలన అవసరాలు ఉన్న అప్లికేషన్లకు ఇది చాలా ముఖ్యం.

9. మ్యాప్డ్ రకాలతో జెనరిక్స్‌ను ఉపయోగించడం

మ్యాప్డ్ రకాలు ఒక రకం యొక్క ప్రాపర్టీలను మరొక రకం ఆధారంగా మార్చడానికి మిమ్మల్ని అనుమతిస్తాయి. ఫ్లెక్సిబిలిటీ కోసం వాటిని జెనరిక్స్‌తో కలపండి:

            
type OptionsFlags = {
  [K in keyof T]: boolean;
};

interface FeatureFlags {
  darkMode: boolean;
  notifications: boolean;
}

// Create a type where each feature flag is enabled (true) or disabled (false)
let featureFlags: OptionsFlags = {
  darkMode: true,
  notifications: false,
};

            

              
                Copy
              
            
          

OptionsFlags రకం ఒక జెనరిక్ రకం T ను తీసుకుని, T యొక్క ప్రాపర్టీలు ఇప్పుడు బూలియన్ విలువలకు మ్యాప్ చేయబడిన ఒక కొత్త రకాన్ని సృష్టిస్తుంది. కాన్ఫిగరేషన్లు లేదా ఫీచర్ ఫ్లాగ్‌లతో పనిచేయడానికి ఇది చాలా శక్తివంతమైనది.

ప్రపంచవ్యాప్త అనువర్తనం: ఈ నమూనా ప్రాంత-నిర్దిష్ట సెట్టింగ్‌ల ఆధారంగా కాన్ఫిగరేషన్ స్కీమాలను సృష్టించడానికి అనుమతిస్తుంది. ఈ విధానం డెవలపర్‌లకు ప్రాంత-నిర్దిష్ట కాన్ఫిగరేషన్లను (ఉదా., ఒక ప్రాంతంలో మద్దతు ఉన్న భాషలు) నిర్వచించడానికి అనుమతిస్తుంది. ఇది గ్లోబల్ అప్లికేషన్ కాన్ఫిగరేషన్ స్కీమాల సులభమైన సృష్టి మరియు నిర్వహణను అనుమతిస్తుంది.

10. `infer` కీవర్డ్‌తో అధునాతన ఇన్ఫరెన్స్

infer కీవర్డ్ కండిషనల్ రకాలలో ఇతర రకాల నుండి రకాలను సంగ్రహించడానికి మిమ్మల్ని అనుమతిస్తుంది.

            
type ReturnType any> = T extends (...args: any) => infer R ? R : any;

function myFunction(): string {
  return "hello";
}

let result: ReturnType = "hello"; // result is string

            

              
                Copy
              
            
          

ఈ ఉదాహరణ infer కీవర్డ్‌ను ఉపయోగించి ఒక ఫంక్షన్ యొక్క రిటర్న్ రకాన్ని ఊహిస్తుంది. ఇది మరింత అధునాతన టైప్ మానిప్యులేషన్ కోసం ఒక అధునాతన టెక్నిక్.

ప్రపంచవ్యాప్త ప్రాముఖ్యత: ఈ టెక్నిక్ పెద్ద, పంపిణీ చేయబడిన గ్లోబల్ సాఫ్ట్‌వేర్ ప్రాజెక్టులలో సంక్లిష్ట ఫంక్షన్ సిగ్నేచర్లు మరియు సంక్లిష్ట డేటా నిర్మాణాలతో పనిచేసేటప్పుడు టైప్ సేఫ్టీని అందించడానికి చాలా ముఖ్యమైనది. ఇది ఇతర రకాల నుండి డైనమిక్‌గా రకాలను ఉత్పత్తి చేయడానికి అనుమతిస్తుంది, కోడ్ నిర్వహణను మెరుగుపరుస్తుంది.

ఉత్తమ పద్ధతులు మరియు చిట్కాలు

• అర్థవంతమైన పేర్లను ఉపయోగించండి: చదవడానికి వీలుగా మీ జెనరిక్ టైప్ పరామితులకు వివరణాత్మక పేర్లను (ఉదా., TValue, TKey) ఎంచుకోండి.
• మీ జెనరిక్స్‌ను డాక్యుమెంట్ చేయండి: మీ జెనరిక్ రకాలు మరియు కన్స్ట్రెయింట్స్ యొక్క ఉద్దేశ్యాన్ని వివరించడానికి JSDoc వ్యాఖ్యలను ఉపయోగించండి. ఇది జట్టు సహకారానికి, ముఖ్యంగా ప్రపంచవ్యాప్తంగా పంపిణీ చేయబడిన జట్లతో చాలా ముఖ్యం.
• సరళంగా ఉంచండి: మీ జెనరిక్స్‌ను అతిగా ఇంజనీరింగ్ చేయవద్దు. సాధారణ పరిష్కారాలతో ప్రారంభించి, మీ అవసరాలు అభివృద్ధి చెందుతున్నప్పుడు రిఫ్యాక్టర్ చేయండి. అతి-సంక్లిష్టత కొంతమంది జట్టు సభ్యులకు అవగాహనను అడ్డుకోవచ్చు.
• పరిధిని పరిగణించండి: మీ జెనరిక్ టైప్ పరామితుల పరిధిని జాగ్రత్తగా పరిగణించండి. అనుకోని టైప్ అసమతుల్యతలను నివారించడానికి అవి సాధ్యమైనంత సంకుచితంగా ఉండాలి.
• ఇప్పటికే ఉన్న యుటిలిటీ రకాలను ఉపయోగించుకోండి: సాధ్యమైనప్పుడల్లా టైప్‌స్క్రిప్ట్ యొక్క అంతర్నిర్మిత యుటిలిటీ రకాలను ఉపయోగించుకోండి. అవి మీకు సమయం మరియు శ్రమను ఆదా చేయగలవు.
• క్షుణ్ణంగా పరీక్షించండి: మీ జెనరిక్ కోడ్ వివిధ రకాలతో ఊహించిన విధంగా పనిచేస్తుందని నిర్ధారించుకోవడానికి సమగ్ర యూనిట్ పరీక్షలు రాయండి.

ముగింపు: ప్రపంచవ్యాప్తంగా జెనరిక్స్ శక్తిని స్వీకరించడం

టైప్‌స్క్రిప్ట్ జెనరిక్స్ దృఢమైన మరియు నిర్వహించగల కోడ్ రాయడానికి ఒక మూలస్తంభం. ఈ అధునాతన నమూనాలను ప్రావీణ్యం పొందడం ద్వారా, మీరు మీ జావాస్క్రిప్ట్ అప్లికేషన్ల టైప్ సేఫ్టీ, పునర్వినియోగం మరియు మొత్తం నాణ్యతను గణనీయంగా మెరుగుపరచవచ్చు. సాధారణ టైప్ కన్స్ట్రెయింట్స్ నుండి సంక్లిష్ట కండిషనల్ రకాల వరకు, జెనరిక్స్ ప్రపంచ ప్రేక్షకుల కోసం స్కేలబుల్ మరియు నిర్వహించగల సాఫ్ట్‌వేర్‌ను నిర్మించడానికి మీకు అవసరమైన సాధనాలను అందిస్తాయి. మీ భౌగోళిక స్థానంతో సంబంధం లేకుండా జెనరిక్స్‌ను ఉపయోగించే సూత్రాలు స్థిరంగా ఉంటాయని గుర్తుంచుకోండి.

ఈ వ్యాసంలో చర్చించిన టెక్నిక్‌లను వర్తింపజేయడం ద్వారా, మీరు మెరుగైన నిర్మాణాత్మక, మరింత విశ్వసనీయమైన మరియు సులభంగా విస్తరించగల కోడ్‌ను సృష్టించవచ్చు, చివరికి మీరు ఏ దేశం, ఖండం, లేదా వ్యాపారంతో సంబంధం లేకుండా మరింత విజయవంతమైన సాఫ్ట్‌వేర్ ప్రాజెక్టులకు దారితీస్తుంది. జెనరిక్స్‌ను స్వీకరించండి, మరియు మీ కోడ్ మీకు ధన్యవాదాలు తెలుపుతుంది!